export default {
	leftZero(str) {
		return ('00' + str).substr(str.length);
	},

	str2Date(dateStr, separator) {
		if (!separator) {
			separator = '-';
		}
		let dateArr = dateStr.split(separator);
		let year = parseInt(dateArr[0], 0);
		let month;
		//处理月份为04这样的情况
		if (dateArr[1].indexOf('0') == 0) {
			month = parseInt(dateArr[1].substring(1), 0);
		} else {
			month = parseInt(dateArr[1], 0);
		}
		let day = parseInt(dateArr[2], 0);
		let date = new Date(year, month - 1, day);
		return date;
	},

	/**
	 * 校验yyyy-MM-dd HH:mm:ss
	 */
	checkDateTime(date) {
		var reg = /^(\d{1,4})(-|\/)(\d{1,2})\2(\d{1,2}) (\d{1,2}):(\d{1,2}):(\d{1,2})$/;
		var r = date.match(reg);
		if (r == null) {
			// alert('输入格式不正确，请按yyyy-MM-dd HH:mm:ss的格式输入！');
			this.$message.error('输入格式不正确，请按yyyy-MM-dd HH:mm:ss的格式输入！');
			return false;
		} else {
			return true;
		}
	},
	/**
	 * 校验yyyy-MM-dd
	 * @param {} pattern
	 */
	checkDate(date) {
		var reg = /^(\d{1,4})(-|\/)(\d{1,2})\2(\d{1,2})/;
		var r = date.match(reg);
		if (r == null) {
			// alert('输入格式不正确，请按yyyy-MM-dd的格式输入！');
			this.$message.error('输入格式不正确，请按yyyy-MM-dd的格式输入！');
			return false;
		} else {
			return true;
		}
	},

	/**
	 * 后台接受date类型需要带T的情况,并加后缀T00:00:00
	 * @param {*} date
	 */
	convertDateToNeed(date) {
		if (date == null) {
			return null;
		} else if (date.indexOf('T') >= 0) {
			return date;
		} else {
			return date + 'T00:00:00';
		}
	},

	/**
	 * 处理格式为2019-04-10T19:59:13.000+0800
	 * @param {*} dateTime
	 */
	convertDateTimeToNeed(dateTime) {
		var dateTimeStr = '';
		if (dateTime == null) {
			return null;
		} else if (dateTime.indexOf('T') >= 0) {
			dateTimeStr = dateTime.substr(0, dateTime.length - 9);
			dateTimeStr = dateTimeStr.replace('T', ' ');
		}
		return dateTimeStr;
	},


	formatDate(date, fmt) {
		if(!(date instanceof Date)){
			return date;
		}

		if (/(y+)/.test(fmt)) {
			fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length));
		}
		let o = {
			'M+': date.getMonth() + 1,
			'd+': date.getDate(),
			'h+': date.getHours(),
			'm+': date.getMinutes(),
			's+': date.getSeconds()
		};
		for (let k in o) {
			if (new RegExp(`(${k})`).test(fmt)) {
				let str = o[k] + '';
				fmt = fmt.replace(RegExp.$1, (RegExp.$1.length === 1) ? str : this.leftZero(str));
			}
		}
		return fmt;
	},
	dateFormat(originVal,formate) {
		let dt = '';
		if(originVal!='' && originVal!=undefined && originVal!=null){
			dt = new Date(originVal);
		}else{
			dt = new Date();
		}
		const y = dt.getFullYear()
		const m = (dt.getMonth() + 1 + '').padStart(2, '0')
		const d = (dt.getDate() + '').padStart(2, '0')

		const hh = (dt.getHours() + '').padStart(2, '0')
		const mm = (dt.getMinutes() + '').padStart(2, '0')
		const ss = (dt.getSeconds() + '').padStart(2, '0')
        if (formate=='yyyymmdd'){
            return `${y}${m}${d}`
        } else if (formate == 'yyyy-mm-dd'){
            return `${y}-${m}-${d}`
        }else{
            return `${y}-${m}-${d} ${hh}:${mm}:${ss}`
        }
	},

	// 获取日期  日偏移量
	getOffsetDay(fmt, offset) {
		return this.formatDate(this.getOffsetDayD(offset), fmt);
	},

	// 获取日期  日偏移量
	getOffsetDayD(offset) {
		return new Date(new Date().setDate(new Date().getDate() + offset));
	},

	// 获取日期  月偏移量
	getOffsetMonth(fmt, offset) {
		return this.formatDate(this.getOffsetMonthD(offset), fmt);
	},

	// 获取日期  月偏移量
	getOffsetMonthD(offset) {
		return new Date(new Date().setMonth(new Date().getMonth() + offset));
	},

	// 获取日期  月,日偏移量
	getOffsetMonthDay(fmt, offsetM, offsetD) {
		return this.formatDate(this.getOffsetMonthDayD(offsetM, offsetD), fmt);
	},
	// 获取日期  月,日偏移量
	getOffsetMonthDayD(offsetM, offsetD) {
		let d = new Date(new Date().setMonth(new Date().getMonth() + offsetM));
		return new Date(d.setDate(new Date().getDate() + offsetD));
	},

	// 最小值与最大值限制  minM最小值偏移月 minD 最小值偏移日  maxM最大值偏移月 maxD最大值偏移日
	getMinMaxLimitDate(time,minM,minD,maxM,maxD){
		return time < this.getOffsetMonthDayD(minM,minD) || time > this.getOffsetMonthDayD(maxM,maxD);
	},

	//minM最小值偏移月 minD 最小值偏移日
	getMinLimitDate(time,minM,minD){
		return time < this.getOffsetMonthDayD(minM,minD);
	},

	//maxM最大值偏移月 maxD最大值偏移日
	getMaxLimitDate(time,maxM,maxD){
		return time > this.getOffsetMonthDayD(maxM,maxD);
	},

	/**
	 * 获取本地时区时间
	 * @param {new Date()} currentDate
	 * @param {时区} timeZone
	 */
	getLocaleTimeByTimezone(currentDate, timezone) {
		var offset_GMT = currentDate.getTimezoneOffset(); // 本地时间和格林威治的时间差，单位为分钟
		var nowDate = currentDate.getTime(); // 本地时间的毫秒数
		var targetDate = new Date(nowDate + offset_GMT * 60 * 1000 + timezone * 60 * 60 * 1000);
		return targetDate;
	},

	/**
	 * 获取当前日期的前一天
	 * @param {new Date()} currentDate
	 * @param {格式} fmt
	 */
	getLastDay(currentDate, fmt) {
		var targetDate = this.getLocaleTimeByTimezone(currentDate, 8);
		var lastDay = new Date(targetDate.setDate(targetDate.getDate() - 1));
		return this.formatDate(lastDay, fmt);
	},

	/**
	 * 获取当前日期的上个月
	 * @param {当前日期} currentDate
	 * @param {格式} fmt
	 */
	getLastMonth(currentDate, fmt) {
		var targetDate = this.getLocaleTimeByTimezone(currentDate, 8);
		var lastMonth = new Date(targetDate.setMonth(targetDate.getMonth() - 1));
		return this.formatDate(lastMonth, fmt);
	},
    /**
     * 当前时间是否大于失效时间
     * @param {失效时间} invalidTime
     */
    compareDate(invalidTime) {
        let now = new Date() //当前时间
        let end = new Date(invalidTime.replace(/-/g, "/")) //对比时间
        if (now.getTime() > end.getTime()) {
            //当前时间比指定时间大
            return false
        } else {
            //小于指定时间
            return true
        }
    },
    // 获取后n天的时间
    fun_date(a) {
        var date1 = new Date();
        var date2 = new Date(date1);
        date2.setDate(date1.getDate() + a);
        var time2 = this.dateFormat(date2);
        return time2
    }
};
export const convertDateToNeed = true;
export const convertDateTimeToNeed = true;
export const getLastDay = true;
